//线程等待（程序员不喜欢随机的东西-》线程调度是随机的，所以用线程等待来让某线程先结束某线程堵塞）
public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            for(;;){
                System.out.println("hello thread!");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //throw new RuntimeException(e);
                    break;
                }
            }
        });
        t.start();

        System.out.println("主线程等待之前");
        t.join();//由于join可能触发堵塞，所以可能抛出InterrupteedException异常
        System.out.println("主线程等待之后");

        //主线程中，可以对t线程进行“等待”
        //哪个线程调用join，该线程就是“等的一方”，比如此处，main线程就是等的一方
        //join前面是那个线程对象的引用，对应的线程就是“被等的一方”，此处就是t
        //main线程等待t线程结束
        //字面意思：t要加入到main中，提前是main得存在，所以main的存在时间比t长，所以main等待t
    }
}

/*
t线程等待main线程：

public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        // 获取 main 线程的引用（Thread.currentThread()）
        Thread mainThread = Thread.currentThread();

        Thread t = new Thread(() -> {
            System.out.println("t线程开始，尝试等待 main 线程...");

            // t 线程等待 main 线程结束
            try {
                mainThread.join();  // t 线程在这里阻塞，直到 main 线程结束
            } catch (InterruptedException e) {
                e.printStackTrace();
                return;
            }

            // main 线程结束后，t 线程继续执行
            System.out.println("main 线程已结束，t 线程继续执行...");

            // 原来的 t 线程逻辑
            for (;;) {
                System.out.println("hello thread!");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    break;
                }
            }
        });

        t.start();

        System.out.println("主线程开始执行...");
        Thread.sleep(3000);  // 模拟 main 线程运行 3 秒
        //t.join();相互等待，没有意义，会出现两个线程都无法结束的情况
        System.out.println("主线程即将结束...");
    }
}
*/